﻿#define _CRT_SECURE_NO_WARNINGS 1

#include<iostream>
using namespace std;

//class Person
//{
//public:
//	//⾝份认证 
//	void identity()
//	{
//		cout << "void identity()" << _name << endl;
//	}
//
//	void Print()
//	{
//		cout << _name << endl;
//	}
//
////protected:
//	string _name = "zhangsan"; // 姓名 
//	string _address; // 地址 
//	string _tel; // 电话 
//	int _age = 18; // 年龄 
//};
//
//class Student : public Person
//{
//public:
//	// 学习 
//	void study()
//	{
//		// ...
//	}
////protected:
//	int _stuid; // 学号 
//};
//
//class Teacher : public Person
//{
//public:
//	// 授课 
//	void teaching()
//	{
//		//...
//	}
////protected:
//	string title; // 职称 
//};
//
//int main()
//{
//	Student s;
//	s._name = "lisi";
//	s.Print();
//	
//	Person p;
//	p._name = "zhangsan";
//	p.Print();
//
//	return 0;
//}

//class Person
//{
//public:
//	void Print()
//	{
//		cout << _tel << endl;
//	}
//
//	string _name; // 姓名 
//private:
//	string _tel = "001"; // 电话 
//};
//
//class Student : public Person
//{
//public:
//	//void func()
//	//{
//	//	cout << _tel << endl;
//	//}
//private:
//	int _stuid; // 学号 
//};
//
//int main()
//{
//	Student s;
//	s.Print();
//
//	return 0;
//}

//int main()
//{
//	Person p;
//	Student s;
//
//	p = s;
//	Person* ptr = &s;
//	//派生类赋值给基类不是类型转换
//	//类型转换会产生临时变量，引用需要使用const
//	//这里中间没有产生临时变量，不需要const
//	Person& ref = s;
//
//	return 0;
//}

///////////////////////////////////////////////////
// Student的_num和Person的_num构成隐藏关系，可以看出这样代码虽然能跑，但是⾮常容易混淆 
//class Person
//{
//protected:
//	string _name = "zhangsan"; // 姓名 
//	int _num = 111; // ⾝份证号 
//};
//
//class Student : public Person
//{
//public:
//	void Print()
//	{
//		cout << " 姓名:" << _name << endl;
//		cout << " 学号:" << _num << endl;
//		cout << "身份证号" << Person::_num << endl;
//	}
//protected:
//	int _num = 999; // 学号 
//};
//
//int main()
//{
//	Student s1;
//	s1.Print();
//
//	return 0;
//};

//class A
//{
//public:
//	void fun()
//	{
//		cout << "func()" << endl;
//	}
//};
//
//class B : public A
//{
//public:
//	void fun(int i)
//	{
//		cout << "func(int i)" << i << endl;
//	}
//};
//
//int main()
//{
//	B b;
//	//下面这样调用会报错
//	//因为函数同名构成隐藏
////子类调用时在不指定父类的情况下会调用自己的
////但是子类的需要参数，这里不传参，编译报错
//	//b.fun();
//	b.fun(0);//正确调用
//
//	b.A::fun();//调用父类的
//
//	return 0;
//};

//class Person
//{
//public:
//	Person(const char* name = "peter")
//		: _name(name)
//	{
//			cout << "Person()" << endl;
//	}
//
//	Person(const Person& p)
//		: _name(p._name)
//	{
//		cout << "Person(const Person& p)" << endl;
//	}
//
//	Person& operator=(const Person& p)
//	{
//		cout << "Person operator=(const Person& p)" << endl;
//		if (this != &p)
//			_name = p._name;
//
//		return *this;
//	}
//
//	~Person()
//	{
//		cout << "~Person()" << endl;
//	}
//
//	void func()
//	{
//
//	}
//
//protected:
//	string _name; // 姓名 
//};
//
//class Student :public Person
//{
//public:
//	Student()
//	{
//		cout << "Student()" << endl;
//	}
//	Student(const char* name, int x,const char* address)
//		//:_name(name) 不可以这样写，必须调用父类构造
//		: Person(name)//正确写法
//		, _x(x)
//		,address(address)
//	{
//		cout << "Student()" << endl;
//	}
//
//	Student(const Student& st)
//		:Person(st)//对于父类成员要调用父类的拷贝构造
//		,_x(st._x)
//		,address(st.address)
//	{
//		cout << "Student()" << endl;
//	}
//
//	Student& operator=(const Student& st)
//	{
//		if (this != &st)
//		{
//			Person::operator=(st);
//			_x = st._x;
//			address = st.address;
//		}
//	}
//
//	//~Student()
//	//{
//	//	//~Person(); //这样直接调用会报错
//	//	Person::~Person();
//
//	//	//...执行子类独有数据的析构逻辑
//	//}
//
//	~Student()
//	{
//		cout << "~Student()" << endl;
//	}
//
//private:
//	int _x;
//	string address;
//};

//int main()
//{
//	Student s;
//	return 0;
//}

//int main()
//{
//	//Student s; 
//	Student s("zhangsan", 1, "tianjin");
//	Student s2(s);
//	return 0;
//}

//class Student;
//class Person
//{
//public:
//	friend void Display(const Person& p, const Student& s);
//
//protected:
//	string _name; // 姓名 
//};
//
//class Student : public Person
//{
//protected:
//	int _stuNum; // 学号 
//};
//
//void Display(const Person& p, const Student& s)
//{
//	cout << p._name << endl;
//	cout << s._stuNum << endl;
//}
//
//int main()
//{
//	Person p;
//	Student s;
//	// 编译报错：error: Display⽆法访问 protected 成员 “Student::_stuNum”
//	// 解决⽅案：Display也变成Student 的友元即可 
//	Display(p, s);
//
//	return 0;
//}

//class Person
//{
//public:
//	string _name;
//	static int _count;
//};
//int Person::_count = 0;
//
//class Student : public Person
//{
//protected:
//	int _stuNum;
//};
//
//int main()
//{
//	Person p;
//	Student s;
//	// 这⾥的运行结果可以看到非静态成员_name的地址是不⼀样的 
//	// 说明派⽣类继承下来了，⽗派⽣类对象各有⼀份 
//	cout << &p._name << endl;
//	cout << &s._name << endl;
//	// 这⾥的运行结果可以看到静态成员_count的地址是⼀样的 
//	// 说明派⽣类和基类共⽤同⼀份静态成员 
//	cout << &p._count << endl;
//	cout << &s._count << endl;
//	// 公有的情况下，⽗类,派⽣类指定类域都可以访问静态成员 
//	cout << Person::_count << endl;
//	cout << Student::_count << endl;
//	return 0;
//}

//class Person
//{
//public:
//		string _name; // 姓名 
//};
//
//class Student : public Person
//{
//protected:
//	int _num; //学号 
//};
//
//class Teacher : public Person
//{
//protected:
//	int _id; // 职⼯编号 
//};
//
//class Assistant : public Student, public Teacher
//{
//protected:
//	string _majorCourse; // 主修课程 
//};

//int main()
//{
//	Assistant a;
//	a._name = "小李";
//
//	return 0;
//}

//int main()
//{
//	Assistant a;
//	a.Student::_name = "小李";
//	a.Teacher::_name = "李老师";
//
//	return 0;
//}

//class Person
//{
//public:
//		string _name; // 姓名 
//};
//
//class Student : virtual public Person
//{
//protected:
//	int _num; //学号 
//};
//
//class Teacher : virtual public Person
//{
//protected:
//	int _id; // 职⼯编号 
//};
//
//class Assistant : public Student, public Teacher
//{
//protected:
//	string _majorCourse; // 主修课程 
//};
//
//int main()
//{
//	Assistant a;
//	a._name = "zhangsan";
//	return 0;
//}

//class Tire 
//{
//protected:
//	string _brand = "Michelin"; // 品牌 
//	size_t _size = 17; // 尺⼨ 
//};
//
//class Car 
//{
//protected:
//	string _colour = "⽩⾊"; // 颜⾊ 
//	string _num = "陕ABIT00"; // ⻋牌号 
//	//组合
//	//在 car 中有一个 Tire
//	Tire _t; // 轮胎 
//};

//class Person
//{
//public:
//	virtual void BuyTicket()
//	{
//		cout << "买票-全价" << endl;
//	}
//};
//
//class Student :public Person
//{
//public:
//	virtual void BuyTicket()
//	{
//		cout << "买票-半价" << endl;
//	}
//};
//
//void func(Person& p)
//{
//	p.BuyTicket();
//}
//
////隐藏和重写
//int main()
//{
//	Person p;
//	Student s;
//	//构成多态
//	//展现多态的效果
//	func(p);
//	func(s);
//
//	//不构成多态
//	//展现隐藏的效果
//	s.BuyTicket();
//	//可以显示调用父类的方法
//	//这里是隐藏，不是多态
//	s.Person::BuyTicket();
//	return 0;
//}
//
//class Student :public Person
//{
//public:
//	void BuyTicket()
//	{
//		cout << "买票-半价" << endl;
//	}
//};

//void func(Person* p)
//{
//	p->BuyTicket();
//}
//
// 验证多态-父类指针
//int main()
//{
//	Person p;
//	Student s;
//
//	func(&p);
//	func(&s);
//
//	return 0;
//}

//验证多态-父类引用
//int main()
//{
//	Person p;
//	Student s;
//
//	func(p);
//	func(s);
//
//	return 0;
//}

//协变
//class A{};
//class B:public A{};
//
//class Person
//{
//public:
//	virtual A* func(){}
//};
//
//class Student :public Person
//{
//public:
//	virtual B* func(){}
//};

//析构函数重写的意义
//class Person
//{
//public:
//	~Person()
//	{
//		cout << "~Person()" << endl;
//	}
//};
//
//class Student :public Person
//{
//public:
//	~Student()
//	{
//		delete[] arr;
//		cout << "~Student()" << endl;
//	}
//private:
//	int* arr = new int[10];
//};
//
//int main()
//{
//	Person* p = new Student;
//	delete p;
//
//	return 0;
//}

//class Person
//{
//public:
//	virtual ~Person()
//	{
//		cout << "~Person()" << endl;
//	}
//};
//
//class Student :public Person
//{
//public:
//	~Student()
//	{
//		delete[] arr;
//		cout << "~Student()" << endl;
//	}
//private:
//	int* arr = new int[10];
//};
//
//int main()
//{
//	Person* p = new Student;
//	delete p;
//
//	return 0;
//}

//class A
//{
//public:
//	virtual void func(){}
//};
//
//class B :public A
//{
//public:
// //override会报错，没有构成重写
//	virtual int func() override{}
//};

//class A
//{
//public:
//	virtual void func() final {}
//};
//
//class B :public A
//{
//public:
// 无法重写final修饰的虚函数
//	virtual void func(){}
//};

//纯虚函数
//class A
//{
//public:
//	virtual void func() = 0;
//};
//
//class B:public A
//{
//public:
//	virtual void func()
//	{
//		cout << "重写纯虚函数" << endl;
//	}
//};
//
//int main()
//{
//	//A a;
//	B b;
//	b.func();
//	return 0;
//}

//面试题
//class A
//{
//public:
//	virtual void func(int val = 1) { cout << "A->" << val << endl; }
//	virtual void test() { func(); }
//};
//
//class B :public A
//{
//public:
//	virtual void func(int val = 0) { cout << "B->" << val << endl; }
//};
//
//int main()
//{
//	B* p = new B;
//	p->test();
//	return 0;
//}

//验证虚表
//class Base
//{
//public:
//	virtual void func(){}
//private:
//	int _a;
//	char _b;
//};
//
//int main()
//{
//	cout << sizeof(Base) << endl;
//	Base b;
//
//	return 0;
//}

